package com.example.smssender;

import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 联系人列表适配器
 */
public class ContactAdapter extends RecyclerView.Adapter<ContactAdapter.ViewHolder> {
    
    private static final String TAG = "ContactAdapter";
    
    private List<Contact> contacts;
    private OnContactClickListener listener;
    private Set<Integer> selectedPositions;  // 使用 position 而不是 contactId 来跟踪选中状态
    private Set<String> selectedContactIds;  // 使用 contactId 作为持久化选中状态，防止列表刷新后丢失
    private Set<String> selectedContactKeys;  // 使用 contactKey (ID|phone) 作为精确的选中状态，处理多个联系人共享同一ID的情况
    private boolean isSelectMode = false;
    
    /**
     * 生成联系人的唯一键（ID+电话号码组合），用于精确匹配
     * 这样可以处理多个联系人共享同一个ID的情况
     */
    private static String getContactKey(Contact contact) {
        if (contact == null) {
            return null;
        }
        String id = contact.getId() != null ? contact.getId() : "";
        String phone = contact.getPhoneNumber() != null ? contact.getPhoneNumber() : "";
        return id + "|" + phone; // 使用 | 分隔符，因为电话号码中不会包含这个字符
    }

    public interface OnContactClickListener {
        void onContactClick(Contact contact);
        void onContactLongClick(Contact contact);
        void onContactSelectionChanged(Contact contact, boolean isSelected);
    }

    public ContactAdapter(List<Contact> contacts, OnContactClickListener listener) {
        this.contacts = contacts;
        this.listener = listener;
        this.selectedPositions = new HashSet<>();
        this.selectedContactIds = new HashSet<>();
        this.selectedContactKeys = new HashSet<>();
    }
    
    /**
     * 更新联系人列表（用于搜索过滤等场景）
     * 会保留选中状态，并基于新的联系人列表重新恢复选中状态
     */
    public void updateContacts(List<Contact> newContacts) {
        if (newContacts == null) {
            this.contacts = new ArrayList<>();
        } else {
            this.contacts = newContacts;
        }
        // 重新恢复选中状态（基于 selectedContactKeys，确保即使列表变化也能正确恢复）
        restoreSelectionsFromContactKeys();
    }
    
    public void setSelectMode(boolean selectMode) {
        Log.d(TAG, "setSelectMode: " + selectMode + ", 当前选中数量=" + getSelectedCount());
        this.isSelectMode = selectMode;
        if (!selectMode) {
            selectedPositions.clear();
            selectedContactIds.clear();
            selectedContactKeys.clear();
            Log.d(TAG, "setSelectMode: 退出选择模式，清空选中集合");
        } else {
            // 进入选择模式时，基于contactKey恢复选中状态（更精确，避免ID重复问题）
            restoreSelectionsFromContactKeys();
        }
        notifyDataSetChanged();
    }
    
    /**
     * 获取当前列表中选中的联系人ID集合
     * 只返回当前 contacts 列表中存在的选中联系人ID，排除已删除的无效选中项
     * 注意：由于多个联系人可能共享同一个ID，此方法返回的是唯一ID集合
     * 如果需要获取所有选中的联系人（包括相同ID的多个联系人），请使用 getSelectedContacts()
     */
    public Set<String> getSelectedContactIds() {
        Set<String> validSelectedIds = new HashSet<>();
        if (contacts != null && selectedContactIds != null) {
            // 构建当前contacts列表的ID集合，用于验证
            Set<String> validContactIds = new HashSet<>();
            for (Contact contact : contacts) {
                if (contact != null && contact.getId() != null) {
                    validContactIds.add(contact.getId());
                }
            }
            // 只返回在当前contacts列表中存在的选中ID
            for (String contactId : selectedContactIds) {
                if (validContactIds.contains(contactId)) {
                    validSelectedIds.add(contactId);
                }
            }
        }
        return validSelectedIds;
    }
    
    /**
     * 获取当前列表中所有选中的联系人列表
     * 基于 selectedPositions 返回，确保即使多个联系人共享同一个ID也能正确返回所有选中的联系人
     * 这是获取选中联系人的推荐方法
     */
    public List<Contact> getSelectedContacts() {
        List<Contact> selectedContacts = new ArrayList<>();
        if (contacts != null && selectedPositions != null) {
            for (Integer position : selectedPositions) {
                if (position >= 0 && position < contacts.size()) {
                    Contact contact = contacts.get(position);
                    if (contact != null && contact.getId() != null) {
                        selectedContacts.add(contact);
                    }
                }
            }
        }
        return selectedContacts;
    }
    
    public void selectAll() {
        if (isSelectMode && contacts != null) {
            selectedPositions.clear();
            selectedContactIds.clear();
            selectedContactKeys.clear();
            for (int i = 0; i < contacts.size(); i++) {
                Contact contact = contacts.get(i);
                if (contact != null && contact.getId() != null) {
                    selectedPositions.add(i);
                    selectedContactIds.add(contact.getId()); // 保留contactId用于向后兼容
                    String contactKey = getContactKey(contact);
                    if (contactKey != null) {
                        selectedContactKeys.add(contactKey); // 使用contactKey作为精确标识
                    }
                }
            }
            notifyDataSetChanged();
            // 批量操作后，只触发一次回调通知 UI 更新（避免多次更新标题）
            if (listener != null && !selectedPositions.isEmpty()) {
                // 使用第一个联系人作为代表触发回调（实际数量通过 getSelectedCount() 获取）
                Contact firstContact = null;
                for (Contact contact : contacts) {
                    if (contact != null && contact.getId() != null) {
                        firstContact = contact;
                        break;
                    }
                }
                if (firstContact != null) {
                    listener.onContactSelectionChanged(firstContact, true);
                }
            }
        }
    }
    
    public void deselectAll() {
        if (contacts != null) {
            boolean hadSelections = !selectedPositions.isEmpty();
            selectedPositions.clear();
            selectedContactIds.clear();
            selectedContactKeys.clear();
            notifyDataSetChanged();
            // 批量操作后，只触发一次回调通知 UI 更新（避免多次更新标题）
            if (listener != null && hadSelections) {
                // 使用第一个联系人作为代表触发回调（实际数量通过 getSelectedCount() 获取）
                Contact firstContact = null;
            for (Contact contact : contacts) {
                    if (contact != null && contact.getId() != null) {
                        firstContact = contact;
                        break;
                    }
                }
                if (firstContact != null) {
                    listener.onContactSelectionChanged(firstContact, false);
                }
            }
        }
    }
    
    /**
     * 设置初始选中的联系人列表
     * 用于在打开选择页面时，恢复之前已选择的联系人状态
     * @param initialSelectedContacts 初始选中的联系人列表
     */
    public void setInitialSelectedContacts(List<Contact> initialSelectedContacts) {
        if (initialSelectedContacts == null || initialSelectedContacts.isEmpty()) {
            Log.d(TAG, "setInitialSelectedContacts: 初始选中列表为空，清空选中状态");
            selectedPositions.clear();
            selectedContactIds.clear();
            selectedContactKeys.clear();
            notifyDataSetChanged();
            return;
        }
        
        Log.d(TAG, "setInitialSelectedContacts: 设置 " + initialSelectedContacts.size() + " 个初始选中联系人");
        
        // 清空当前选中状态
        selectedPositions.clear();
        selectedContactIds.clear();
        selectedContactKeys.clear();
        
        // 构建初始选中联系人的 contactKey 集合
        Set<String> initialContactKeys = new HashSet<>();
        Set<String> initialContactIds = new HashSet<>();
        for (Contact contact : initialSelectedContacts) {
            if (contact != null) {
                String contactKey = getContactKey(contact);
                if (contactKey != null) {
                    initialContactKeys.add(contactKey);
                }
                if (contact.getId() != null) {
                    initialContactIds.add(contact.getId());
                }
            }
        }
        
        // 保存初始选中的 contactKeys 和 contactIds
        selectedContactKeys.addAll(initialContactKeys);
        selectedContactIds.addAll(initialContactIds);
        
        // 如果 contacts 列表已加载，立即恢复选中状态
        if (contacts != null && !contacts.isEmpty()) {
            restoreSelectionsFromContactKeys();
            Log.d(TAG, "setInitialSelectedContacts: 已恢复 " + selectedPositions.size() + " 个选中状态");
        } else {
            Log.d(TAG, "setInitialSelectedContacts: contacts 列表未加载，将在列表加载后自动恢复选中状态");
        }
        
        notifyDataSetChanged();
        
        // 触发一次回调通知 UI 更新
        if (listener != null && !initialSelectedContacts.isEmpty()) {
            Contact firstContact = initialSelectedContacts.get(0);
            if (firstContact != null) {
                listener.onContactSelectionChanged(firstContact, true);
            }
        }
    }
    
    public boolean isAllSelected() {
        if (!isSelectMode || contacts == null || contacts.isEmpty()) {
            return false;
        }
        // 获取有效的联系人数量（排除 null 值）
        int validContactCount = 0;
        for (Contact contact : contacts) {
            if (contact != null && contact.getId() != null) {
                validContactCount++;
            }
        }
        // 如果有效联系人数量为 0，返回 false
        if (validContactCount == 0) {
            return false;
        }
        // 比较选中的有效联系人数量与有效联系人总数
        return getSelectedCount() == validContactCount;
    }
    
    /**
     * 获取当前列表中实际选中的联系人数量
     * 只统计当前 contacts 列表中存在的选中联系人，排除已删除的无效选中项
     */
    public int getSelectedCount() {
        if (contacts == null || contacts.isEmpty()) {
            return 0;
        }
        int count = 0;
        for (Integer position : selectedPositions) {
            if (position >= 0 && position < contacts.size()) {
                Contact contact = contacts.get(position);
                if (contact != null && contact.getId() != null) {
                    count++;
                }
            }
        }
        return count;
    }
    
    /**
     * 清理无效的选中状态（用于联系人列表更新后）
     * 自动移除已删除联系人的选中状态
     * 注意：此方法应该在每次列表更新后调用，以确保 selectedPositions 与当前列表同步
     * 
     * 使用 contactKey (ID|phone) 和 contactId 作为持久化选中状态，
     * 当列表重新加载时，基于这些键恢复选中状态
     * contactKey 用于精确匹配（处理多个联系人共享同一ID的情况），
     * contactId 用于向后兼容
     */
    public void cleanupInvalidSelections(List<Contact> validContacts) {
        if (validContacts == null) {
            selectedPositions.clear();
            selectedContactIds.clear();
            return;
        }
        
        // 移除已删除联系人的 contactId（不在当前列表中的）
        Set<String> validContactIds = new HashSet<>();
        for (Contact contact : validContacts) {
            if (contact != null && contact.getId() != null) {
                validContactIds.add(contact.getId());
            }
        }
        
        // 清理无效的 contactId
        Set<String> invalidContactIds = new HashSet<>();
        for (String contactId : selectedContactIds) {
            if (!validContactIds.contains(contactId)) {
                invalidContactIds.add(contactId);
            }
        }
        selectedContactIds.removeAll(invalidContactIds);
        
        // 清理无效的 contactKey
        Set<String> validContactKeys = new HashSet<>();
        for (Contact contact : validContacts) {
            if (contact != null) {
                String key = getContactKey(contact);
                if (key != null) {
                    validContactKeys.add(key);
                }
            }
        }
        Set<String> invalidContactKeys = new HashSet<>();
        if (selectedContactKeys != null) {
            for (String contactKey : selectedContactKeys) {
                if (!validContactKeys.contains(contactKey)) {
                    invalidContactKeys.add(contactKey);
                }
            }
            selectedContactKeys.removeAll(invalidContactKeys);
        }
        
        // 重新构建 selectedPositions 基于 selectedContactKeys（优先）或 selectedContactIds
        restoreSelectionsFromContactKeys();
        
        if (!invalidContactIds.isEmpty()) {
            Log.d(TAG, "cleanupInvalidSelections: 清理了 " + invalidContactIds.size() + " 个无效的 contactId");
        }
    }
    
    /**
     * 基于 selectedContactKeys 恢复 selectedPositions（优先使用，更精确）
     * 如果没有contactKey，则回退到使用 selectedContactIds
     * 当列表重新加载后，使用此方法确保选中状态正确恢复
     * 注意：只恢复当前 contacts 列表中存在的联系人，确保选中状态与当前显示列表一致
     */
    private void restoreSelectionsFromContactKeys() {
        selectedPositions.clear();
        if (contacts == null || contacts.isEmpty()) {
            return;
        }
        
        int restoredCount = 0;
        // 优先使用contactKey进行精确匹配
        if (selectedContactKeys != null && !selectedContactKeys.isEmpty()) {
            for (int i = 0; i < contacts.size(); i++) {
                Contact contact = contacts.get(i);
                if (contact != null) {
                    String contactKey = getContactKey(contact);
                    if (contactKey != null && selectedContactKeys.contains(contactKey)) {
                        selectedPositions.add(i);
                        restoredCount++;
                    }
                }
            }
            Log.d(TAG, "restoreSelectionsFromContactKeys: 使用contactKey恢复了 " + restoredCount + " 个选中状态（当前列表中共 " + contacts.size() + " 个联系人，selectedContactKeys中共 " + selectedContactKeys.size() + " 个key）");
        } else if (selectedContactIds != null && !selectedContactIds.isEmpty()) {
            // 回退到使用contactId（向后兼容）
            for (int i = 0; i < contacts.size(); i++) {
                Contact contact = contacts.get(i);
                if (contact != null && contact.getId() != null 
                        && selectedContactIds.contains(contact.getId())) {
                    selectedPositions.add(i);
                    restoredCount++;
                }
            }
            Log.d(TAG, "restoreSelectionsFromContactIds: 使用contactId恢复了 " + restoredCount + " 个选中状态（当前列表中共 " + contacts.size() + " 个联系人，selectedContactIds中共 " + selectedContactIds.size() + " 个ID）");
        }
    }
    
    /**
     * 基于 selectedContactIds 恢复 selectedPositions（向后兼容方法）
     * @deprecated 使用 restoreSelectionsFromContactKeys() 代替，更精确
     */
    @Deprecated
    private void restoreSelectionsFromContactIds() {
        restoreSelectionsFromContactKeys();
    }

    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext())
            .inflate(R.layout.item_contact, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        // 使用 position 参数，避免闭包捕获导致的问题
        if (contacts == null || position < 0 || position >= contacts.size()) {
            Log.w(TAG, "onBindViewHolder: 无效位置 position=" + position + ", contacts.size()=" + (contacts == null ? 0 : contacts.size()));
            return;
        }
        Contact contact = contacts.get(position);
        if (contact == null) {
            Log.w(TAG, "onBindViewHolder: position=" + position + " 联系人为 null");
            holder.tvName.setText("");
            holder.tvPhoneNumber.setText("");
            holder.checkBox.setVisibility(View.GONE);
            return;
        }
        
        String contactId = contact.getId();
        String contactName = contact.getName();
        Log.d(TAG, "onBindViewHolder: position=" + position + ", contactId=" + contactId + ", name=" + contactName);
        
        holder.tvName.setText(contactName != null ? contactName : "");
        holder.tvPhoneNumber.setText(contact.getPhoneNumber() != null ? contact.getPhoneNumber() : "");
        
        // 清除所有之前的监听器，避免复用 ViewHolder 时出现状态混乱
        holder.checkBox.setOnCheckedChangeListener(null);
        holder.checkBox.setOnClickListener(null);
        holder.itemView.setOnClickListener(null);
        holder.itemView.setOnLongClickListener(null);
        
        // 设置CheckBox显示和选中状态
        if (isSelectMode) {
            holder.checkBox.setVisibility(View.VISIBLE);
            // 根据当前 position 的实际选中状态设置 CheckBox
            // 注意：此时监听器已在上面清除，所以设置状态不会触发回调
            boolean isSelected = selectedPositions.contains(position);
            Log.d(TAG, "onBindViewHolder: position=" + position + ", contactId=" + contactId + ", 设置CheckBox状态=" + isSelected + ", 当前选中集合大小=" + selectedPositions.size());
            holder.checkBox.setChecked(isSelected);
            
            // 使用 OnCheckedChangeListener 监听 CheckBox 状态变化
            // 注意：使用闭包捕获的 position 和 contact，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
            final int bindPosition = position;
            final Contact bindContact = contact;
            
            // 创建监听器，避免代码重复
            android.widget.CompoundButton.OnCheckedChangeListener checkChangeListener = (buttonView, isChecked) -> {
                Log.d(TAG, "CheckBox状态变化: bindPosition=" + bindPosition + ", bindContactId=" + bindContact.getId() + ", isChecked=" + isChecked);
                // 使用绑定时的 position，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
                if (bindPosition < 0 || bindPosition >= contacts.size() || contacts == null) {
                    Log.w(TAG, "CheckBox状态变化: 位置无效 bindPosition=" + bindPosition + ", contacts.size()=" + (contacts == null ? 0 : contacts.size()));
                    return; // 位置无效，直接返回
                }
                Contact currentContact = contacts.get(bindPosition);
                // 双重验证：确保联系人ID匹配，避免ViewHolder复用导致的问题
                if (currentContact == null || currentContact.getId() == null 
                        || !currentContact.getId().equals(bindContact.getId())) {
                    Log.w(TAG, "CheckBox状态变化: 联系人验证失败 - currentContact=" + (currentContact == null ? "null" : currentContact.getId()) + ", bindContactId=" + bindContact.getId());
                    return; // 联系人无效或ID不匹配，直接返回
                }
                // 根据 CheckBox 的新状态更新选中列表（使用 position 而不是 contactId）
                boolean wasSelected = selectedPositions.contains(bindPosition);
                Log.d(TAG, "CheckBox状态变化: contactId=" + currentContact.getId() + ", position=" + bindPosition + ", wasSelected=" + wasSelected + ", isChecked=" + isChecked);
                if (isChecked) {
                    // CheckBox被选中了，添加到选中列表
                    selectedPositions.add(bindPosition);
                    String contactKey = getContactKey(currentContact);
                    String currentContactId = currentContact.getId();
                    selectedContactIds.add(currentContactId); // 保留contactId用于向后兼容
                    if (contactKey != null) {
                        selectedContactKeys.add(contactKey); // 使用contactKey作为精确标识
                    }
                    Log.d(TAG, "CheckBox选中: contactId=" + currentContactId + ", contactKey=" + contactKey + ", position=" + bindPosition + ", 当前选中集合大小=" + selectedPositions.size());
                    // 只有当状态真正改变时才触发回调（避免重复回调）
                    if (!wasSelected && listener != null) {
                        Log.d(TAG, "CheckBox选中: 触发回调 - contactId=" + currentContactId);
                            listener.onContactSelectionChanged(currentContact, true);
                    } else {
                        Log.d(TAG, "CheckBox选中: 跳过回调 - wasSelected=" + wasSelected + ", listener=" + (listener == null ? "null" : "not null"));
                    }
                } else {
                    // CheckBox被取消选中了，从选中列表移除
                    selectedPositions.remove(bindPosition);
                    String contactKey = getContactKey(currentContact);
                    String currentContactId = currentContact.getId();
                    selectedContactIds.remove(currentContactId); // 移除contactId
                    if (contactKey != null) {
                        selectedContactKeys.remove(contactKey); // 移除contactKey
                    }
                    Log.d(TAG, "CheckBox取消选中: contactId=" + currentContactId + ", contactKey=" + contactKey + ", position=" + bindPosition + ", 当前选中集合大小=" + selectedPositions.size());
                    // 只有当状态真正改变时才触发回调（避免重复回调）
                    if (wasSelected && listener != null) {
                        Log.d(TAG, "CheckBox取消选中: 触发回调 - contactId=" + currentContactId);
                            listener.onContactSelectionChanged(currentContact, false);
                    } else {
                        Log.d(TAG, "CheckBox取消选中: 跳过回调 - wasSelected=" + wasSelected + ", listener=" + (listener == null ? "null" : "not null"));
                    }
                }
            };
            
            // 设置监听器
            holder.checkBox.setOnCheckedChangeListener(checkChangeListener);
            
            // itemView 点击事件：切换选中状态
            // 注意：点击 CheckBox 时，CheckBox 会消费点击事件，itemView 的点击不会被触发
            // 但 CheckBox 的默认行为会自动切换状态并触发 OnCheckedChangeListener
            // 所以点击 CheckBox 和点击 itemView 都能正常工作
            holder.itemView.setOnClickListener(v -> {
                Log.d(TAG, "itemView点击: bindPosition=" + bindPosition + ", bindContactId=" + bindContact.getId());
                // 使用绑定时的 position，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
                if (bindPosition < 0 || bindPosition >= contacts.size() || contacts == null) {
                    Log.w(TAG, "itemView点击: 位置无效 bindPosition=" + bindPosition);
                    return;
                }
                Contact currentContact = contacts.get(bindPosition);
                // 双重验证：确保联系人ID匹配，避免ViewHolder复用导致的问题
                if (currentContact == null || currentContact.getId() == null 
                        || !currentContact.getId().equals(bindContact.getId())) {
                    Log.w(TAG, "itemView点击: 联系人验证失败 - currentContactId=" + (currentContact == null ? "null" : currentContact.getId()) + ", bindContactId=" + bindContact.getId());
                    return;
                }
                // 选择模式：切换选中状态
                boolean wasSelected = selectedPositions.contains(bindPosition);
                boolean newSelectedState = !wasSelected;
                Log.d(TAG, "itemView点击: contactId=" + currentContact.getId() + ", position=" + bindPosition + ", 当前选中状态=" + wasSelected + ", 将切换为=" + newSelectedState);
                
                // 如果状态没有真正改变，直接返回（理论上不会发生，但为了健壮性）
                if (wasSelected == newSelectedState) {
                    Log.w(TAG, "itemView点击: 状态未改变，跳过处理 - contactId=" + currentContact.getId());
                    return;
                }
                
                // 先清除监听器，避免触发不必要的回调
                holder.checkBox.setOnCheckedChangeListener(null);
                // 切换 CheckBox 状态
                holder.checkBox.setChecked(newSelectedState);
                // 手动更新选中状态
                String contactKey = getContactKey(currentContact);
                String currentContactId = currentContact.getId();
                if (newSelectedState) {
                    selectedPositions.add(bindPosition);
                    selectedContactIds.add(currentContactId); // 保留contactId用于向后兼容
                    if (contactKey != null) {
                        selectedContactKeys.add(contactKey); // 使用contactKey作为精确标识
                    }
                    Log.d(TAG, "itemView点击: 已选中 - contactId=" + currentContactId + ", contactKey=" + contactKey + ", position=" + bindPosition + ", 当前选中集合大小=" + selectedPositions.size());
                } else {
                    selectedPositions.remove(bindPosition);
                    selectedContactIds.remove(currentContactId); // 移除contactId
                    if (contactKey != null) {
                        selectedContactKeys.remove(contactKey); // 移除contactKey
                    }
                    Log.d(TAG, "itemView点击: 已取消选中 - contactId=" + currentContactId + ", contactKey=" + contactKey + ", position=" + bindPosition + ", 当前选中集合大小=" + selectedPositions.size());
                }
                // 触发回调（状态已改变，总是触发）
                if (listener != null) {
                    Log.d(TAG, "itemView点击: 触发回调 - contactId=" + currentContact.getId() + ", isSelected=" + newSelectedState);
                    listener.onContactSelectionChanged(currentContact, newSelectedState);
                }
                // 恢复监听器
                holder.checkBox.setOnCheckedChangeListener(checkChangeListener);
                Log.d(TAG, "itemView点击: 已切换CheckBox状态并更新选中列表，恢复监听器");
            });
        } else {
            holder.checkBox.setVisibility(View.GONE);
            
            // 普通模式：设置点击和长按监听器
            // 使用绑定时的 position 和 contact，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
            final int bindPosition = position;
            final Contact bindContact = contact;
            
            holder.itemView.setOnClickListener(v -> {
                // 使用绑定时的 position，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
                if (bindPosition < 0 || bindPosition >= contacts.size() || contacts == null) {
                    Log.w(TAG, "itemView点击(普通模式): 位置无效 bindPosition=" + bindPosition);
                    return;
                }
                Contact currentContact = contacts.get(bindPosition);
                // 双重验证：确保联系人ID匹配，避免ViewHolder复用导致的问题
                if (currentContact == null || currentContact.getId() == null 
                        || !currentContact.getId().equals(bindContact.getId())) {
                    Log.w(TAG, "itemView点击(普通模式): 联系人验证失败 - currentContactId=" + (currentContact == null ? "null" : currentContact.getId()) + ", bindContactId=" + bindContact.getId());
                    return;
                }
                if (listener == null) {
                    return;
                }
                Log.d(TAG, "itemView点击(普通模式): contactId=" + currentContact.getId() + ", name=" + currentContact.getName() + ", position=" + bindPosition);
                listener.onContactClick(currentContact);
            });
            
            holder.itemView.setOnLongClickListener(v -> {
                // 使用绑定时的 position，而不是 getAdapterPosition()，避免ViewHolder复用导致的位置错误
                if (bindPosition < 0 || bindPosition >= contacts.size() || contacts == null) {
                    Log.w(TAG, "itemView长按(普通模式): 位置无效 bindPosition=" + bindPosition);
                    return false;
                }
                Contact currentContact = contacts.get(bindPosition);
                // 双重验证：确保联系人ID匹配，避免ViewHolder复用导致的问题
                if (currentContact == null || currentContact.getId() == null 
                        || !currentContact.getId().equals(bindContact.getId())) {
                    Log.w(TAG, "itemView长按(普通模式): 联系人验证失败 - currentContactId=" + (currentContact == null ? "null" : currentContact.getId()) + ", bindContactId=" + bindContact.getId());
                    return false;
                }
                // 只在普通模式下触发长按删除（非选择模式）
                if (isSelectMode || listener == null) {
                    return false;
                }
                Log.d(TAG, "itemView长按(普通模式): contactId=" + currentContact.getId() + ", name=" + currentContact.getName() + ", position=" + bindPosition);
                listener.onContactLongClick(currentContact);
                return true;
            });
        }
    }

    @Override
    public int getItemCount() {
        return contacts == null ? 0 : contacts.size();
    }

    static class ViewHolder extends RecyclerView.ViewHolder {
        CheckBox checkBox;
        TextView tvName;
        TextView tvPhoneNumber;

        ViewHolder(View itemView) {
            super(itemView);
            checkBox = itemView.findViewById(R.id.checkBox);
            tvName = itemView.findViewById(R.id.tvName);
            tvPhoneNumber = itemView.findViewById(R.id.tvPhoneNumber);
        }
    }
}

